

//引入 Electron 中的 contextBridge（是一个安全机制，用于将主进程中的API暴露给渲染进程） 和
//  ipcRenderer(渲染进程与主进程异步通信的主要工具，允许发送信息和接收信息) 模块，以便在渲染进程中使用它们。
const {contextBridge, ipcRenderer} = require('electron');

// 使用 contextBridge.exposeInMainWorld 方法，将一个名为 electronAPI 的对象暴露到渲染进程的全局上下文中。这样可以安全地与主进程进行交互。
contextBridge.exposeInMainWorld(
    'electronAPI', {
        // 定义一个函数 sendSettings，它接受一个参数 data，并使用 ipcRenderer.send 方法发送一个名为 'send-settings' 的消息到主进程，同时携带 data 作为载荷。
        sendSettings: (data) => {
            ipcRenderer.send('send-settings', data);
            // ipcRenderer.once('server-not-connect', () => {
            //     console.log('server not connect')
            // })
        },
        // 定义 sendSettingsCallback 函数，它接受一个回调 data，并注册一个监听器，当主进程发送 'server-not-connect' 消息时，调用该回调。
        sendSettingsCallback: (data) => {
            ipcRenderer.on('server-not-connect',data)
        },
        // 定义 reconnectServer 函数，向主进程发送 'reconnect-server' 消息，表示请求重连服务器。
        reconnectServer: () => {
            ipcRenderer.send('reconnect-server');
            // 注册一个单次监听器，当主进程发送 'connect-failed' 消息时，打印 'cannot connect to server'。
            ipcRenderer.once('connect-failed', () => {
                console.log('cannot connect to server')
            });
            ipcRenderer.once('connect-succeed', () => {
                console.log('successfully connect to server')
            })
        },
        // 定义 connectServerCallback 函数，接受一个回调 callback，并注册一个监听器，当主进程发送 'connect-callback' 消息时调用该回调。
        connectServerCallback: (callback) => {
            ipcRenderer.on('connect-callback', callback);
        },
        // 定义 serverDataCallback 函数，注册监听器，当主进程发送 'server-data-callback' 消息时调用传入的回调。
        serverDataCallback: (callback) => {
            ipcRenderer.on('server-data-callback', callback);
        },
        // 定义 pingServer 函数，向主进程发送 'ping-server' 消息，表示请求对服务器的 ping 操作。
        pingServer:() => {
            ipcRenderer.send('ping-server');
            ipcRenderer.once('ping-already', () => {
                console.log('ping already')
            })
        },
        // 定义 pingDevice 函数，接受一个 ip 参数，并向主进程发送 'ping-device' 消息，携带 ip 作为载荷。
        pingDevice: (ip) => {
          ipcRenderer.send('ping-device', ip);
        },
        // 定义 pingDeviceCallback 函数，注册监听器，当主进程发送 'ping-callback' 消息时调用传入的回调。
        pingDeviceCallback: (callback) => {
          ipcRenderer.on('ping-callback', callback);
        },
    

        //到时候需要加一行代码open的（发送的）12.5fm
        runOpenVPN:(room) => ipcRenderer.send('open-vpn', room),
        onRunOpenVPNSuccess: (callback) => ipcRenderer.on('open-success', callback),
        onRunOpenVPNFailed: (callback) => ipcRenderer.on('oprn-failed', callback),
        closeOpenVPN:()=> ipcRenderer.send('close-open'),
        removeRunOpenVPNSuccessListener: () => ipcRenderer.removeAllListeners('open-success'),
        removeRunOpenVPNStoppedListener: () => ipcRenderer.removeAllListeners('open-failed'),
        // 发送请求修改配置文件(修改和读取的)
        requestSend:()=> ipcRenderer.send('modify-config'),
        // 监听修改结果
        change:()=> ipcRenderer.on('config-modified', (event, message) => {
        console.log(message); // 打印修改结果
       }),
    


        //对N2N的一系列操作
        //发送的
        runN2N: (room) =>  ipcRenderer.send('run-n2n', room),
        onRunN2NSuccess: (callback) => ipcRenderer.on('n2n-success', callback),
        onRunN2NFailed: (callback) => ipcRenderer.on('n2n-failed', callback),
        closeN2N:()=> ipcRenderer.send('close-n2n'),
        removeRunN2NSuccessListener: () => ipcRenderer.removeAllListeners('n2n-success'),
        removeRunN2NStoppedListener: () => ipcRenderer.removeAllListeners('n2n-failed'),

        
        connRemote: (data) => {
            ipcRenderer.send('conn-remote', data)
        },
        connRemoteCallback: (callback) => {
            ipcRenderer.on('conn-result', callback);
        },
        disconnectRemote: () => {
          ipcRenderer.send('disconnect-remote');
        },
        requestIP: ()=> {
            ipcRenderer.send('request-ip');
        },
        getIp: (ip)=> {
            ipcRenderer.on('send-ip', ip);
        },
        removeGetIpListener: () => ipcRenderer.removeAllListeners('send-ip'),
        serialPortMapping: (data) => {
            ipcRenderer.send('serial-port-mapping', data)
        },
        // 定义 removeAllEvent 函数，移除所有注册的监听器，以避免内存泄漏和不必要的事件处理。
        removeAllEvent: ()=> {
            ipcRenderer.removeAllListeners('server-not-connect');
            ipcRenderer.removeAllListeners('connect-callback');
            ipcRenderer.removeAllListeners('server-data-callback');
            ipcRenderer.removeAllListeners('ping-callback');
            ipcRenderer.removeAllListeners('n2n-success');
            ipcRenderer.removeAllListeners('n2n-failed');
            ipcRenderer.removeAllListeners('send-ip');
            ipcRenderer.removeAllListeners('conn-result');
            ipcRenderer.removeAllListeners('update_available');
            ipcRenderer.removeAllListeners('update_downloaded');
            
            //清除指令12.5 fm
            ipcRenderer.removeAllListeners('open-success');
            ipcRenderer.removeAllListeners('open-failed');

        },
        // 定义 getWifiNetworks 函数，使用 ipcRenderer.invoke 方法向主进程请求获取 Wi-Fi 网络信息。
        getWifiNetworks: () => ipcRenderer.invoke('get-wifi-networks'),
        autoUpdate: (downloadUrl) => {
            ipcRenderer.send('start-update', downloadUrl);
        },
        sendVideoData: (data) => ipcRenderer.send('video-data', data),
        // 定义 onVideoData 函数，注册监听器，当主进程发送 'video-data' 消息时调用传入的回调，并将接收到的数据传递给回调。
        onVideoData: (callback) => ipcRenderer.on('video-data', (event, data) => callback(data)),
       
    }
)
// 总体目的是为 Electron 应用提供一个清晰的接口，使得渲染进程可以与主进程进行各种操作，如发送消息、获取数据和注册事件监听器等。
// 通过 contextBridge 的使用，它确保了安全性，避免了直接暴露整个 ipcRenderer 对象。